/* 
 * File:   DbConn.cpp
 * Author: batista
 * 
 * Created on 20 de Fevereiro de 2013, 08:38
 */


#include "DbConn.h"

/**
 * Metodo construtor da aplicação
 */
DbConn::DbConn(DirFile* dirfl, string host, string db, string port, string user, string pass) {
    //
    msg = new ShowMsg();
    //
    tmut = new TimeUtil();
    //
    this->dir = dirfl;
    //
    SetHostname(host);
    //
    SetDatabase(db);
    //
    SetPort(port);
    //
    SetUsername(user);
    //
    SetPassword(pass);

    msg->ShowMessage("Mensagem: Construtor Principal DbConn()!!", COLOR_BLUE, COLOR_PINK);
    //
    //Abre banco Sqlite na memoria
    openConnInSqLite();
}

/**
 * Metodo destrutor 
 * da aplicação
 */
DbConn::~DbConn() {
    //Fecha PostgreSql
    closeConnPGree();
    //
    //Fecha Sqlite3
    closeConnSqLite();
    //
}

/**
 * Metodo responsavel por abrir uma conexao com o banco de dados
 * 
 * @return true ou false
 * -------------------------------------------------------------
 *          Driver     |    Database
 * -------------------------------------------------------------
 *       QDB2          |  IBM DB2 version 7.1and later
 *       QIBASE        |  Borland InterBase
 *       QMYSQL        |  MySQL
 *       QOCI          |  Oracle (Oracle Call Interface)
 *       QODBC         |  ODBC (includes Microsoft SQL Server)
 *       QPSQL         |  PostgreSQL 7.3 and later
 *       QSQLITE       |  SQLite version 3
 *       QSQLITE2      |  SQLite version 2
 *       QTDS          |  Sybase Adaptive Server
 * -------------------------------------------------------------
 */
bool DbConn::openConnInPGree() {
    string erro_log;

    /**
     * Se foi possivel abrir o arquivo
     * de configuracao, entra para abrir
     * o banco de dados.
     * @return 
     */
    if (!GetHostname().empty() && !GetDatabase().empty() &&
            !GetUsername().empty() && !GetPassword().empty()) {
        //
        //string url_database = "host=" + local_address + " dbname=" + database + " user=" + userdb + " password=" + passwd;
        string url_conn = "host=" + GetHostname() + " dbname=" + GetDatabase() + " user=" + GetUsername() + " password=" + GetPassword();


        msg->ShowMessage("Abrindo Conexao PostgreSql!! " + url_conn, COLOR_BLUE, COLOR_PINK);
        //
        conn = PQconnectdb(url_conn.c_str());
    }

    if (PQstatus(conn) != CONNECTION_OK) {
        char *erro_searc = PQerrorMessage(conn);
        //
        erro_log = "OpenConn(): Nao foi possivel abri PostgreSql -> " + string(erro_searc);
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/PgSql/");
        //
        dir->CreateLogFile("LOGPGSQL", erro_log);
        //
        return false;
    }
    //
    msg->ShowMessage("Aberta a Conexao PostgreSql com Sucesso!!", COLOR_BLUE, COLOR_PINK);
    //
    return true;
}

/**
 * Metodo responsavel por 
 * verficar se a conexao 
 * esta disponivel, ativa.
 * @return 
 */
bool DbConn::isOpenConnPGree() {
    string erro_log;
    //
    //Verifica se esta aberta
    if (PQstatus(conn) != CONNECTION_OK) {
        char *erro_searc = PQerrorMessage(conn);
        //
        erro_log = "OpenConn(): Nao foi possivel abri PostgreSql -> " + string(erro_searc);
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/PgSql/");
        //
        dir->CreateLogFile("LOGPGSQL", erro_log);
        //
        return false;
    }
    //
    return true;
}

/**
 * Fecha a conexao
 * @return true ou false
 */
void DbConn::closeConnPGree() {
    /*Verifica se a conexao está aberta e a encerra*/
    if (conn != NULL) {
        PQfinish(conn);
        //
        msg->ShowMessage("CloseConn(), Conexao fechada com sucesso!!!", COLOR_BLUE, COLOR_RED);
    }
}

/**
 * Metodo responsavel por pegar todos 
 * os cartões
 * @return 
 */
vector<Card*> DbConn::getAllCards() {
    //
    vector<Card*> vec_all_cards;
    //
    msg->ShowMessage("Lendo todos os Cartoes Cadastrados do Banco PostgreSql!!", COLOR_BLUE, COLOR_CIANO);
    //string database, userdb, passwddb;
    string query = "SELECT * FROM attendants";
    //
    int i, nrows;
    //

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //
                    evcard = new Card();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0);
                    //CARD_CODE
                    char *vhexacode_card = PQgetvalue(rs, i, 1);
                    //CARD_NAME
                    //char *vattendant_name = PQgetvalue(rs, i, 2);
                    //CLIENT_CODE
                    //char *vattendant_code = PQgetvalue(rs, i, 3);
                    //
                    evcard->SetAttendant_Id(string(vid));
                    evcard->SetHexa_Card(string(vhexacode_card));
                    //evcard->SetAttendant_Code(string(vattendant_code));
                    //
                    // if (!string(vattendant_name).empty()) {
                    //     evcard->SetAttendant_Name(string(vattendant_name));
                    // } else {
                    //     evcard->SetAttendant_Name(evcard->GetAttendant_Code());
                    // }

                    //
                    vec_all_cards.push_back(evcard);
                }
            } else {
                //                setPath_multitone_write(getSystem_path());
                string erro_query = "Cartões não encontrados para query: " + query;
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //                
                dir->CreateLogFile("CARDS-NOT-FOUND", erro_query);
            }

            PQclear(rs);
        }

        //Fecha a conexao
        closeConnPGree();
        //
    }
    //
    return vec_all_cards;
}

/**
 * Metodo responsavel por pegar todos 
 * os eventos da Rauland.
 * @return vector<Event>
 */
vector<Event*> DbConn::getAllEvents() {
    vector<Event*> vec_all_events;
    //
    msg->ShowMessage("Lendo todos as Eventos da Rauland do Banco PostgreSql!!", COLOR_BLUE, COLOR_CIANO);
    //
    string query = "SELECT * FROM table_events WHERE event_name IS NOT NULL ORDER BY event_code";
    //
    int i, nrows;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //Executa a query
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //
                    evrld = new Event();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                    //EVENT_CODE
                    //char *vevent_code = PQgetvalue(rs, i, 1);

                    //SHORT_NAME
                    // char *vshort_name = PQgetvalue(rs, i, 2);

                    //EVENT_NAME
                    char *vevent_name = PQgetvalue(rs, i, 3);

                    //IS_CANCEL
                    char *viscancel = PQgetvalue(rs, i, 4);
                    //
                    evrld->SetEventId(atoi(vid));
                    //evrld->SetEventCode(string(vevent_code));
                    evrld->SetEventMessage(string(vevent_name));
                    //
                    if (string(viscancel) == "t") {
                        evrld->SetEventCancel(true);
                    } else {
                        evrld->SetEventCancel(false);
                    }
                    //
                    vec_all_events.push_back(evrld);
                    //
                }
            } else {
                string erro_query = "Evento não encontradas para query: " + query;
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //   
                dir->CreateLogFile("EVENTS-NOT-FOUND", erro_query);
            }

            PQclear(rs);
        }

        //Fecha a conexao com o banco
        closeConnPGree();
        //
    }
    //
    return vec_all_events;
}

/**
 * Metodo responsavel por pegar todas 
 * as alas 
 * @return vector<Wards>
 */
vector<Ward*> DbConn::getAllWards() {
    vector<Ward*> vec_all_wards;

    msg->ShowMessage("Lendo todas as Alas do Banco PostgreSql!!", COLOR_BLUE, COLOR_CIANO);

    string query = "SELECT * FROM wards WHERE short_name IS NOT NULL";
    int i, nrows;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        //Executa a query    
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //
                    ward = new Ward();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna
                    //PORTA SERIAL
                    char *vserial_port = PQgetvalue(rs, i, 1);
                    //CODIGO DA ALA
                    //char *vward_code = PQgetvalue(rs, i, 2);
                    //NOME CURTO DA ALA
                    char *vshort_name = PQgetvalue(rs, i, 3);
                    //NOME LONGO DA ALA
                    //char *vward_name = PQgetvalue(rs, i, 4);
                    //
                    ward->SetWardId(string(vid));
                    ward->SetWardPds(string(vserial_port));
                    //ward->SetWardCode(string(vward_code));
                    ward->SetWardSigla(string(vshort_name));
                    // ward->SetWardName(string(vward_name));
                    //
                    vec_all_wards.push_back(ward);

                }
                //
            } else {
                string erro_query = "Alas não encontradas para query: " + query;
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                dir->CreateLogFile("WARDS-NOT-FOUND", erro_query);
            }
            //

            //
            PQclear(rs);
        }

        //Fecha a conexao do postgre
        closeConnPGree();
        //  
    }
    //
    return vec_all_wards;
}

/**
 * Metodo responsavel por pegar
 * todos os quartos
 * @return vector<Rooms>
 */
vector<Room*> DbConn::getAllRooms() {
    vector<Room*> vec_all_rooms;

    //
    msg->ShowMessage("Lendo todos os Quartos do Banco PostgreSql!!", COLOR_BLUE, COLOR_CIANO);
    //
    string query = "SELECT * FROM rooms WHERE room_name IS NOT NULL ORDER BY ward_id";
    int i, nrows;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        //Executa a query    
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //
                    room = new Room();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna
                    //WARD_ID
                    char *vward_id = PQgetvalue(rs, i, 1);
                    //ROOM_CODE
                    char *vroom_code = PQgetvalue(rs, i, 2);
                    //ROOM_NAME
                    char *vroom_name = PQgetvalue(rs, i, 3);
                    //
                    room->SetRoomId(string(vid));
                    room->SetRoomWardId(string(vward_id));
                    room->SetRoomCode(string(vroom_code));
                    room->SetRoomName(string(vroom_name));
                    //
                    vec_all_rooms.push_back(room);
                    msg->ShowMessage("Quantidade lida: " + room->GetRoomName(), COLOR_BLUE, COLOR_CIANO);
                    //
                }
            } else {
                string erro_query = "Quartos não encontrados para query: " + query;
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                dir->CreateLogFile("ROOMS-NOT-FOUND", erro_query);
            }
            //
            PQclear(rs);
        }
        //Fecha a conexao
        closeConnPGree();
        // 
    }
    //
    return vec_all_rooms;
}

/**
 * Metodo responsavel por pegar todos 
 * os Quartos com Alas para os Eventos
 * Capturados.
 * @return vector<Rooms>
 */
vector<Room*> DbConn::getAllWardRoomsToEventCap() {
    vector<Room*> vec_all_rooms;

    //
    msg->ShowMessage("Lendo todos os Quartos do Banco PostgreSql!!", COLOR_BLUE, COLOR_CIANO);
    //
    string query = "SELECT w.short_name, r.room_name  FROM wards w, rooms r "
            "WHERE w.id = r.ward_id AND room_name IS NOT NULL "
            "ORDER BY ward_id";
    int i, nrows;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        //Executa a query    
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //
                    room = new Room();
                    //Sigla da Ala
                    char *vward = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                    //Sigla do Quarto
                    char *vroom = PQgetvalue(rs, i, 1);
                    //
                    room->SetRoomWardSigla(string(vward));
                    room->SetRoomName(string(vroom));
                    //
                    vec_all_rooms.push_back(room);
                    msg->ShowMessage("Quantidade lida: " + room->GetRoomName(), COLOR_BLUE, COLOR_CIANO);
                    //
                }
            } else {
                string erro_query = "Quartos não encontrados para query: " + query;
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                dir->CreateLogFile("ROOMS-NOT-FOUND", erro_query);
            }
            //
            PQclear(rs);
        }
        //Fecha a conexao
        closeConnPGree();
        // 
    }
    //
    return vec_all_rooms;
}

/**
 * Executa uma query no banco
 * PostgreSql
 * @return true or false
 */
bool DbConn::runQueryInPGree(string query) {
    //
    msg->ShowMessage("runQueryInPGree(()", COLOR_WHITE, COLOR_BLUE);
    msg->ShowMessage("Query: " + query, COLOR_WHITE, COLOR_BLUE);

    bool status = false;

    char *error_sql;
    //
    string msg_erro, errosql;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        msg->ShowMessage("Conexao runQueryInPGree((), feita com sucesso", COLOR_WHITE, COLOR_GREEN);
    } else {
        char *erroalt = PQerrorMessage(conn);
        msg->ShowMessage("Erro na Conexao runQueryInPGree(()" + string(erroalt), COLOR_WHITE, COLOR_RED);
        PQfinish(conn);
        return false;
    }

    rs = PQexec(conn, query.c_str());

    if (!rs) {
        msg->ShowMessage("Erro executando Query para runQueryInPGree(()", COLOR_WHITE, COLOR_RED);
        PQclear(rs);
        PQfinish(conn);
        return false;
    } else {
        switch (PQresultStatus(rs)) {
            case PGRES_FATAL_ERROR:
                error_sql = PQresultErrorMessage(rs);
                errosql = string(error_sql);
                msg_erro = "Query Executada: " + query + "\nErro SQL: " + errosql;
                msg->ShowMessage(msg_erro, COLOR_WHITE, COLOR_RED);
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                dir->CreateLogFile("ERRO-SQL", msg_erro);
                break;
            case PGRES_COMMAND_OK:
                status = true;
                break;
            default:
                break;
        }
        /*
         * Para evitar vazamento de memória é necessário chamar PQclear PGresult
         * sempre que este não é mais necessário.
         */
        PQclear(rs);
    }
    //Fecha a conexao com o PostgreSQL
    closeConnPGree();
    //
    return true;
}

/**
 * Metodo responsavel por
 * pegar o tempo programado
 * para o atendimento da 
 * chamada de paciente
 * @return long
 */
long DbConn::getTimeOutForAttend() {
    long time_out = 1;
    int i;

    string query = "SELECT time_out FROM config_hosp";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    char *vcol = PQgetvalue(rs, i, 0); //pego a coluna zero ref, a pes. com uma coluna

                    string str_time_out = string(vcol);

                    if (!str_time_out.empty()) {
                        time_out = atoi(vcol);
                    }
                }
            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "PARAM TIME-OUT NAO CADASTRADO para query: " + query;
                dir->CreateLogFile("ERRO-PARAM-TIME-OUT", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }
    return (time_out * 60);
}

/**
 * Metodo responsavel por pegar o ID
 * e EVENT_NAME e IS_CANCEL para um evento capturado da 
 * Rauland.
 * @param event
 * @return 
 */
Event* DbConn::getEventIDToEventRldInPGree(Event *event) {
    int i;

    string query = "SELECT * FROM table_events WHERE event_name ='" + event->GetEventMessage() + "'";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());

        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                    //EVENT_CODE
                    //char *vevent_code = PQgetvalue(rs, i, 1);

                    //SHORT_NAME
                    // char *vshort_name = PQgetvalue(rs, i, 2);

                    //EVENT_NAME
                    char *vevent_name = PQgetvalue(rs, i, 3);

                    //IS_CANCEL
                    char *viscancel = PQgetvalue(rs, i, 4);
                    //
                    event->SetEventId(atoi(vid));
                    //evrld->SetEventCode(string(vevent_code));
                    event->SetEventMessage(string(vevent_name));

                    //
                    if (string(viscancel) == "t") {
                        event->SetEventCancel(true);
                    } else {
                        event->SetEventCancel(false);
                    }
                }
            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "getEventIDToEventRldInPGree(Event *event):\nNao foi possivel pegar ID para o Evento Rauland:\n" + query;
                dir->CreateLogFile("ERROQUERYEVENT", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }
    //
    return event;
}

/**
 * Metodo responsavel por pegar ward_id, ip_pds
 * ward_code, short_name, e id para um evento 
 * capturado da Rauland.
 * @param event
 * @return 
 */
Ward* DbConn::getWardIDToWardRldInPGree(Event *nevent) {
    int i;

    string query = "SELECT * FROM wards WHERE short_name ='" + nevent->GetWardSigla() + "'";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());

        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    ward = new Ward();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna
                    //PORTA SERIAL
                    char *vserial_port = PQgetvalue(rs, i, 1);
                    //CODIGO DA ALA
                    //char *vward_code = PQgetvalue(rs, i, 2);
                    //NOME CURTO DA ALA
                    char *vshort_name = PQgetvalue(rs, i, 3);
                    //NOME LONGO DA ALA
                    //char *vward_name = PQgetvalue(rs, i, 4);
                    //
                    ward->SetWardId(string(vid));
                    ward->SetWardPds(string(vserial_port));
                    //ward->SetWardCode(string(vward_code));
                    ward->SetWardSigla(string(vshort_name));
                    // ward->SetWardName(string(vward_name));
                }
            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "getWardIDToWardRldInPGree(Event *nevent):\nNao foi possivel pegar ID para a Ala do Evento Rauland:\n" + query;
                dir->CreateLogFile("ERROQUERYWARD", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }
    //
    return ward;
}

/**
 * Metodo responsavel por pegar o id, ward_id
 * room_code, room_name e id para um evento 
 * capturado da Rauland.
 * @param event
 * @return 
 */
Room* DbConn::getRoomIDToRoomRldInPGree(Event *nevent) {
    int i;

    string query = "SELECT * FROM rooms WHERE room_name = '" + nevent->GetRoomSigla()
            + "' AND   ward_id   = '" + nevent->GetWardId() + "'";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());

        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    room = new Room();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna
                    //WARD_ID
                    char *vward_id = PQgetvalue(rs, i, 1);
                    //ROOM_CODE
                    char *vroom_code = PQgetvalue(rs, i, 2);
                    //ROOM_NAME
                    char *vroom_name = PQgetvalue(rs, i, 3);
                    //
                    room->SetRoomId(string(vid));
                    room->SetRoomWardId(string(vward_id));
                    room->SetRoomCode(string(vroom_code));
                    room->SetRoomName(string(vroom_name));
                    //
                }
            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "getRoomIDToRoomRldInPGree(Event *nevent) :\nNao foi possivel pegar ID para o Quarto do Evento Rauland:\n" + query;
                dir->CreateLogFile("ERROQUERYROOM", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }
    //
    return room;
}

/**
 * Metodo responsavel por pegar o id, hexacard
 * para a tabela attendants no PostgreSQL, para 
 * atualizar a tabela local e o evento atual.
 * @param ncard
 * @return 
 */
Card* DbConn::getCardIDToCardInPGree(Card *ncard) {
    int i;

    string query = "SELECT * FROM attendants WHERE hexacard = '" + ncard->GetHexa_Card() + "'";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());

        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    evcard = new Card();
                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna
                    //HexaCard
                    char *vhexacard = PQgetvalue(rs, i, 1);
                    //
                    evcard->SetAttendant_Id(string(vid));
                    evcard->SetHexa_Card(string(vhexacard));
                    //
                }
            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "getCardIDToCardInPGree() :\nNao foi possivel pegar ID para o Cartão Capturado:\n" + query;
                dir->CreateLogFile("ERROQUERYCARD", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }
    //
    return evcard;
}

/**
 * Metodo responsavel por pesquisar um evento
 * na base de dados e ver qual regra de negócio
 * aplicar.
 * @param nevent
 * @return 
 */
Event* DbConn::getTypeEventRldToApplyRule(Event *nevent) {
    int i = 0, nrows;

    string query = "SELECT id, date_time_entered, date_time_exited FROM data_protocol"
            " WHERE ward_id='" + nevent->GetWardId()
            + "' AND room_id='" + nevent->GetRoomId()
            + "' AND date_time_exited IS NULL";


    cerr << FG_RED << "[" << __FILE__ << ":" << __LINE__ << "] "
            << FG_BLUE << "Query...:" << query << END << endl;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/PgSql/");
            //
            string erro_query = "getTypeEventRldToApplyRule() :\nNao foi possivel Executar a Query:\n"
                    + query + "\n Erro: " + str_searc;
            dir->CreateLogFile("ERROQUERYPTL", erro_query);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);

            if (nrows > 0) {
                //     for (i = 0; i < nrows; i++) {
                //ID
                char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                //DATE_TIME_ENTERED
                char *vdatet_entered = PQgetvalue(rs, i, 1);

                //DATE_TIME_EXITED
                char *vdatet_exited = PQgetvalue(rs, i, 2);

                //Seta o ID
                nevent->SetPtlId(atoi(vid));

                //Seta a data de entrada
                nevent->SetDate_Time_Entered(string(vdatet_entered));

                //Seta a data de saida
                nevent->SetDate_Time_Exited(string(vdatet_exited));

                //event_rauland.setIs_cancel(false);
                //
                //              }
            } else {
                //Seta o ID com valor zero para novo evento
                nevent->SetPtlId(0);
            }

            PQclear(rs);
        }
        //Fecha a conexao com o PostgreSQL  
        closeConnPGree();
    }
    //
    return nevent;
}

/**
 * Metodo responsavel por pesquisar um evento
 * na base de dados e ver qual regra de negócio
 * aplicar.
 * @param nevent
 * @return 
 */
Card* DbConn::getTypeCardEventToApplyRule(Card *ncard) {
    int i = 0, nrows;

    string query = "SELECT id, date_time_entered, status_entered, date_time_exited, status_exited FROM data_protocol "
            " WHERE ward_id='" + ncard->GetWardId()
            + "' AND room_id='" + ncard->GetRoomId()
            + "' AND date_time_exited IS NULL";


    cerr << FG_RED << "[" << __FILE__ << ":" << __LINE__ << "] "
            << FG_BLUE << "Query...:" << query << END << endl;

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);

            /**
             * Se entrar no if? Er porque
             * tem um evento para ser atendido
             * ou finalizado. Caso contrario
             * retorna sem um PtlID para para 
             * gerar um Atendimento Espontaneo.
             */
            if (nrows > 0) {
                //ID
                char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                //DATE_TIME_ENTERED
                char *vdate_time_entered = PQgetvalue(rs, i, 1);

                //STATUS_ENTERED
                char *vstatus_entered = PQgetvalue(rs, i, 2);

                //DATE_TIME_EXITED
                char *vdate_time_exited = PQgetvalue(rs, i, 3);

                //STATUS_EXITED
                char *vstatus_exited = PQgetvalue(rs, i, 4);

                //
                ncard->SetPtlId(atoi(vid));
                //
                ncard->SetDate_Time_Entered(string(vdate_time_entered));
                //
                ncard->SetDate_Time_Exited(string(vdate_time_exited));
                //
                if (string(vstatus_entered) == "t") {
                    ncard->SetEventEntered(true);
                } else {
                    ncard->SetEventEntered(false);
                }

                if (string(vstatus_exited) == "t") {
                    ncard->SetEventExited(true);
                } else {
                    ncard->SetEventExited(false);
                }

            }

            PQclear(rs);
        }

        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
    }
    //
    return ncard;
}

/**
 * Abre uma conexao com o
 * banco Sqlite
 * @return 
 */
bool DbConn::openConnInSqLite() {
    //
    int result;
    char *erro = NULL;
    string erro_log;

    string strfile = dir->getSystem_path() + "/Db/datarauland.db";

    msg->ShowMessage("Abrindo...: " + strfile, COLOR_BLUE, COLOR_PINK);


    if (dir->ValidIfFileExist(strfile)) {
        //
        dir->RemoveFile(strfile);
        //
    }
    //PRAGMA page_size = bytes;
    result = sqlite3_open(":memory:", &dbSqLite);
    //result = sqlite3_open("./Db/datarauland.db", &dbSqLite);
    //result = sqlite3_open("file::memory:", &db);
    //result = sqlite3_open("file::memory:?cache=shared", &db);//com chache compartilhado
    /**
     * If two or more distinct but shareable in-memory databases 
     * are needed in a single process, then the mode=memory query 
     * parameter can be used with a URI filename to create a named 
     * in-memory database: 
     */
    //result = sqlite3_open("file:memdb1?mode=memory&cache=shared", &db);

    if (result) {
        //
        erro_log = "openConnInSqLite(): Não foi possível abrir o banco de dados. Erro: -> "
                + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //        
        sqlite3_close(dbSqLite);
    }

    /**
     * Se foi possivel abrir o
     * banco, entra para criar 
     * as tabelas.
     * @return 
     */
    // if (!result) {
    /**
     * Cria a tabela de Alas
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE wards (id INT(11), ip_pds varchar(15), "
            "ward_name varchar(50));", NULL, NULL, &erro);

    //Popula a tabela de alas criada
    runPopWardToTblSqLite();

    /**
     * Cria a tabela de Quartos
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE rooms (id INT(11), ward_id INT(11), "
            "room_code INT(11), room_name varchar(15));", NULL, NULL, &erro);

    //Popula a tabela de Quartos criada
    runPopRoomToTblSqLite();


    /**
     * Cria a tabela de Eventos
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE table_events (id INT(11), "
            "event_name varchar(50), is_cancel bool(1));", NULL, NULL, &erro);

    //Popula a tabela de eventos Rauland
    runPopEventToTblSqLite();

    /**
     * Cria a tabela de Atendentes
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE attendants (id INT(11), hexacard varchar(15));", NULL, NULL, &erro);

    //Popula a tabela de Atendants
    runPopCardToTblSqLite();

    /**
     * Cria a tabela de eventos temporarios
     * de captura da Rauland
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE event_rauland (id INT(11), ward_name VARCHAR(10), "
            "room_name VARCHAR(10), bedroom_code CHAR(2), message_event VARCHAR(30), "
            "is_event_cancel BOOLEAN(1), date_call DATETIME);", NULL, NULL, &erro);

    /**
     * Cria a tabela de eventos temporarios
     * de captura dos Cartões RFID
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE event_card (id INT(11), ward_pds VARCHAR(15), hexa_code VARCHAR(10), date_call DATETIME);", NULL, NULL, &erro);

    /**
     * Cria a tabela de Eventos Capturados 
     * para Ala. Para ser verificado possiveis 
     * duplicacoes de Eventos da Rauland
     * @return 
     */
    sqlite3_exec(dbSqLite, "CREATE TABLE event_cap (id INT(11), ward_name VARCHAR(10), "
            "room_name VARCHAR(10), message_event VARCHAR(30));", NULL, NULL, &erro);

    /**
     * Metodo responsavel por popular todas as 
     * Alas e Quartos para os eventos que serao
     * capturados.
     * @return 
     */
    runAddWardRoomEventToCompareSqLite();


    //  }
    if (erro != NULL) {
        printf("Commit Failed!: %s\n", sqlite3_errmsg(dbSqLite));
        printf("Erro na criacao!: %s\n", erro);
        delete erro;
    }
    //
    return true;
}

/**
 * Verifica se ha uma conexao
 * aberta com o banco Sqlite
 * @return 
 */
bool DbConn::isOpenConnSqLite() {
    string erro_log;
    //
    if (getLastIdFromTblSqLite("wards") == 0) {
        //
        erro_log = "isOpenConnSqLite(): Não foi possível abrir o banco de dados. "
                "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Fecha uma conexao com o
 * banco Sqlite
 */
void DbConn::closeConnSqLite() {
    //   sqlite3_close(dbSqLite);//Nao usar, quando abrir em memoria
}

/**
 * Metodo responsavel por retorna 
 * o ultimo id para coluna id.
 * de uma tabela.
 * @param table
 * @return Integer
 */
int DbConn::getLastIdFromTblSqLite(string table) {
    int vid = 0;
    //
    char* errorMessage;
    //
    cout << "Pesquisando Ultimo ID.........." << endl;

    //sqlite3 *db;
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT MAX(id) FROM " + table;

    cout << "Query: " << buffer + '\n' << "\n\n" << endl;

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    rc = sqlite3_step(stmt);

    while (rc == SQLITE_ROW) {
        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vid = sqlite3_column_int(stmt, 0);
            cout << FG_BLUE << "ID Obtido....:" << FG_GREEN << vid << END << endl;
        }
        //
        rc = sqlite3_step(stmt);
    }

    vid++; //Incrementa o id para um novo id para ser incluso

    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);
    //   sqlite3_close(db);//Nao usar, quando abrir em memoria
    //

    return vid;
}

/**
 * Metodo responsavel por popular
 * as alas para a tabela de alas 
 * na memoria do Sqlite3
 * @return 
 */
bool DbConn::runPopWardToTblSqLite() {
    vector<Ward*> vec_wards;
    int rc;
    char* errorMessage;
    string erro_log;
    //
    ward = new Ward();
    //
    msg->ShowMessage("Populando Alas!!", COLOR_BLUE, COLOR_GREEN);
    //
    if (isOpenConnSqLite()) {

        //Pega as alas para popular tabela sqlite
        vec_wards = getAllWards();

        for (int i = 0; i < vec_wards.size(); i++) {
            ward = vec_wards.at(i);

            msg->ShowMessage("Adicionando Alas!!", COLOR_BLUE, COLOR_GREEN);
            //
            sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

            char buffer[] = "INSERT INTO wards VALUES (?, ?, ?)";
            sqlite3_stmt* stmt;
            sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
            //  
            sqlite3_bind_int(stmt, 1, atoi(ward->GetWardId().c_str())); //tem que incrementar id para incluir
            sqlite3_bind_text(stmt, 2, ward->GetWardPds().c_str(), ward->GetWardPds().size(), SQLITE_TRANSIENT);
            // sqlite3_bind_text(stmt, 3, ward->GetWardCode().c_str(), ward->GetWardCode().size(), SQLITE_TRANSIENT);
            sqlite3_bind_text(stmt, 3, ward->GetWardSigla().c_str(), ward->GetWardSigla().size(), SQLITE_TRANSIENT);
            // sqlite3_bind_text(stmt, 5, ward->GetWardName().c_str(), ward->GetWardName().size(), SQLITE_TRANSIENT);
            //
            rc = sqlite3_step(stmt);

            if (rc != SQLITE_DONE) {
                //
                erro_log = "runPopWardToTblSqLite() : Não foi possível adicionar a Ala para o banco de dados. "
                        "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
                //
                msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
                //
                dir->setFolder_write("/Logs/LogDb/Sqlite/");
                //
                dir->CreateLogFile("LOGSQLITE", erro_log);
                // 
            }

            sqlite3_reset(stmt);

            sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

            sqlite3_finalize(stmt);
        }
    } else {
        //
        erro_log = "runPopWardToTblSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar as Alas";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por popular 
 * os quartos para a tabela de quartos
 * na memoria do Sqlite3
 * @return 
 */
bool DbConn::runPopRoomToTblSqLite() {
    vector<Room*> vec_rooms;
    int rc, room_id, ward_id, room_code;
    char* errorMessage;
    string erro_log;
    //
    room = new Room();

    //
    if (isOpenConnSqLite()) {

        //Pega as alas para popular tabela sqlite
        vec_rooms = getAllRooms();

        for (int i = 0; i < vec_rooms.size(); i++) {
            room = vec_rooms.at(i);
            //
            sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

            char buffer[] = "INSERT INTO rooms VALUES (?, ?, ?, ?)";
            sqlite3_stmt* stmt;
            sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
            //
            room_id = atoi(room->GetRoomId().c_str());
            ward_id = atoi(room->GetRoomWardId().c_str());
            room_code = atoi(room->GetRoomCode().c_str());
            //
            sqlite3_bind_int(stmt, 1, room_id); //tem que incrementar id para incluir
            sqlite3_bind_int(stmt, 2, ward_id);
            sqlite3_bind_int(stmt, 3, room_code);
            sqlite3_bind_text(stmt, 4, room->GetRoomName().c_str(), room->GetRoomName().size(), SQLITE_TRANSIENT);
            //
            rc = sqlite3_step(stmt);

            if (rc != SQLITE_DONE) {
                //
                erro_log = "runPopRoomToTblSqLite() : Não foi possível adicionar os Quartos para o banco de dados. "
                        "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
                //
                msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
                //
                dir->setFolder_write("/Logs/LogDb/Sqlite/");
                //
                dir->CreateLogFile("LOGSQLITE", erro_log);
                // 
            }

            sqlite3_reset(stmt);

            sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

            sqlite3_finalize(stmt);
        }
    } else {
        //
        erro_log = "runPopRoomToTblSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar os Quartos";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //
    }
    //
    return true;
}

/**
 * Metodo responsavel por popular
 * os Cartoes cadastrados para a 
 * tabela de cartoes na memoria do
 * Sqlite3
 * @return 
 */
bool DbConn::runPopCardToTblSqLite() {
    vector<Card*> vec_cards;
    int rc;
    char* errorMessage;
    string erro_log;
    //
    evcard = new Card();

    //
    if (isOpenConnSqLite()) {

        //Pega as alas para popular tabela sqlite
        vec_cards = getAllCards();

        for (int i = 0; i < vec_cards.size(); i++) {
            evcard = vec_cards.at(i);
            //
            sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

            char buffer[] = "INSERT INTO attendants VALUES (?, ?)";
            sqlite3_stmt* stmt;
            sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
            //  
            sqlite3_bind_int(stmt, 1, atoi(evcard->GetAttendant_Id().c_str())); //tem que incrementar id para incluir
            sqlite3_bind_text(stmt, 2, evcard->GetHexa_Card().c_str(), evcard->GetHexa_Card().size(), SQLITE_TRANSIENT);
            // sqlite3_bind_text(stmt, 3, evcard->GetAttendant_Name().c_str(), evcard->GetAttendant_Name().size(), SQLITE_TRANSIENT);
            // sqlite3_bind_text(stmt, 4, evcard->GetAttendant_Code().c_str(), evcard->GetAttendant_Code().size(), SQLITE_TRANSIENT);
            //
            rc = sqlite3_step(stmt);

            if (rc != SQLITE_DONE) {
                //
                erro_log = "runPopCardToTblSqLite() : Não foi possível adicionar os Cartões para o banco de dados. "
                        "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
                //
                msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
                //
                dir->setFolder_write("/Logs/LogDb/Sqlite/");
                //
                dir->CreateLogFile("LOGSQLITE", erro_log);
                // 
            }

            sqlite3_reset(stmt);

            sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

            sqlite3_finalize(stmt);
        }
    } else {
        //
        erro_log = "runPopCardToTblSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar os Cartões";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //
    }
    //
    return true;
}

/**
 * Metodo responsavel por popular 
 * os Eventos da Rauland para tabela
 * de eventos na memoria do Sqlite3 
 * @return 
 */
bool DbConn::runPopEventToTblSqLite() {
    //
    vector<Event*> vec_events;
    int rc, is_cancel;
    char* errorMessage;
    string erro_log;
    //
    evrld = new Event();

    //
    if (isOpenConnSqLite()) {

        //Pega as alas para popular tabela sqlite
        vec_events = getAllEvents();

        for (int i = 0; i < vec_events.size(); i++) {
            evrld = vec_events.at(i);

            //
            sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

            char buffer[] = "INSERT INTO table_events VALUES (?, ?, ?)";
            sqlite3_stmt* stmt;
            sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
            //  
            is_cancel = evrld->IsEventCancel();
            //
            sqlite3_bind_int(stmt, 1, evrld->GetEventId()); //tem que incrementar id para incluir
            //sqlite3_bind_text(stmt, 2, evrld->GetEventCode().c_str(), evrld->GetEventCode().size(), SQLITE_TRANSIENT);
            sqlite3_bind_text(stmt, 2, evrld->GetEventMessage().c_str(), evrld->GetEventMessage().size(), SQLITE_TRANSIENT);
            sqlite3_bind_int(stmt, 3, is_cancel);
            //
            rc = sqlite3_step(stmt);

            if (rc != SQLITE_DONE) {
                //
                erro_log = "runPopEventToTblSqLite() : Não foi possível adicionar a Eventos Padrões Rauland, para o banco de dados. "
                        "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
                //
                msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
                //
                dir->setFolder_write("/Logs/LogDb/Sqlite/");
                //
                dir->CreateLogFile("LOGSQLITE", erro_log);
                // 
            }

            sqlite3_reset(stmt);

            sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

            sqlite3_finalize(stmt);
        }
    } else {
        //
        erro_log = "runPopEventToTblSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar Eventos Padrões Rauland,";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por pegar os eventos
 * disponiveis para que seja aplicada a regra de 
 * negocio. e adicionar em uma tabela no banco 
 * PostgreSQL.
 * @return 
 */
vector<Event*> DbConn::getEventToWorkFromSqLite() {
    vector<Event*> vec_events_to_work;
    //
    //  id, ward_name, room_name, bedroom_code, message_event,
    //  is_event_cancel, date_call
    string vward, vroom, vbedroom, vevent, vdatecall;
    int vid = 0;
    bool event_cancel;
    //
    char* errorMessage;
    //

    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM event_rauland";

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    rc = sqlite3_step(stmt);

    while (rc == SQLITE_ROW) {
        evrld = new Event();
        //
        //cout << "Encontrou algo" << endl;
        //
        if (SQLITE_NULL != sqlite3_column_type(stmt, 1)) {
            vward = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 1));
            evrld->SetWardSigla(vward);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 2)) {
            vroom = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 2));
            evrld->SetRoomSigla(vroom);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 3)) {
            vbedroom = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 3));
            evrld->SetRoomBedCode(vbedroom);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 4)) {
            vevent = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 4));
            evrld->SetEventMessage(vevent);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 5)) {
            event_cancel = sqlite3_column_int(stmt, 5);
            evrld->SetEventCancel(event_cancel);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 6)) {
            vdatecall = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 6));
            evrld->SetDate_Time_Called(vdatecall);
        }

        //Adiciona para lista de eventos
        vec_events_to_work.push_back(evrld);

        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:

        rc = sqlite3_step(stmt);
    }


    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalho com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    //
    return vec_events_to_work;
}

/**
 * Metodo responsavel por pegar os eventos de 
 * Cartoes disponiveis para que seja aplicada 
 * a regra de negocio. e adicionar em uma 
 * tabela no banco PostgreSQL.
 * @return 
 */
vector<Card*> DbConn::getCardToWorkFromSqLite() {
    vector<Card*> vec_eventcard_to_work;
    //
    //  id, ward_name, room_name, bedroom_code, message_event,
    //  is_event_cancel, date_call
    string vwardpds, vhexa_code, vdatecall;
    int vid = 0;
    //
    char* errorMessage;
    //

    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM event_card";

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    rc = sqlite3_step(stmt);

    while (rc == SQLITE_ROW) {
        evcard = new Card();
        //
        //cout << "Encontrou algo" << endl;
        //
        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vid = sqlite3_column_int(stmt, 0);
            evcard->SetIdAdd(vid);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 1)) {
            vwardpds = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 1));
            evcard->SetWardPds(vwardpds);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 2)) {
            vhexa_code = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 2));
            evcard->SetHexa_Card(vhexa_code);
        }

        if (SQLITE_NULL != sqlite3_column_type(stmt, 3)) {
            vdatecall = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 3));
            evcard->SetDate_Time_Called(vdatecall);
        }

        //Adiciona para lista de eventos
        vec_eventcard_to_work.push_back(evcard);

        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:

        rc = sqlite3_step(stmt);
    }


    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalho com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    //
    return vec_eventcard_to_work;
}

/**
 * Metodo responsavel por pegar o id 
 * para um evento capturado da Rauland.
 * @param event
 * @return Event*
 */
Event* DbConn::getEventIDToEventRldInSqLite(Event *nevent) {
    int vevent_id = 0;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM table_events WHERE event_name = ?";

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, nevent->GetEventMessage().c_str(), nevent->GetEventMessage().length(), SQLITE_TRANSIENT);

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vevent_id = sqlite3_column_int(stmt, 0);
            nevent->SetEventId(vevent_id);
        }

        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getEventIDToEventRldInSqLite() : Não foi possível pegar o ID para Evento Rauland para Tabela (table_events)."
                "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    if (vevent_id == 0) {
        nevent = getEventIDToEventRldInPGree(nevent);

        if (nevent->GetEventId() > 0) {
            //Adiciona um evento novo para a tabela local 
            AddEventToTblEventsInSqLite(nevent);
            //
        } else {
            //
            string erro_log = "getEventIDToEventRldInSqLite()() : Evento não Cadastrada Nas "
                    "Tabelas de Pesquisa (table_events) SQ/PG.";
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            //  
            /**
             * Como nao encontrou o Evento em nenhuma 
             * das duas tabelas nos dois bancos.
             * Entao descarta o evento removendo do
             * banco local.
             * @param event
             * @return 
             */
            runRemoveEventInSqLite(nevent);
        }
    }
    //
    return nevent;
}

/**
 * Metodo responsavel por pegar ward_id, ip_pds,
 * ward_code, short_name e ward_name
 * @param ward
 * @return 
 */
Event* DbConn::getWardIDToWardRldInSqLite(Event *nevent) {
    string vward_id;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM wards WHERE ward_name = ?";

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, nevent->GetWardSigla().c_str(), nevent->GetWardSigla().length(), SQLITE_TRANSIENT);

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        //
        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vward_id = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            nevent->SetWardId(vward_id);
        }
        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getWardIDToWardRldInSqLite() : Não foi possível pegar o ID para Ala "
                "Rauland para Tabela (wards). Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    if (vward_id.empty()) {
        ward = new Ward();
        //
        /**
         * Como nao encontrou a Ala na tabela de Alas
         * do SqLite. Faz a pesquisa no PostgreSQL.
         */
        ward = getWardIDToWardRldInPGree(nevent);
        //
        if (!ward->GetWardId().empty()) {
            //
            nevent->SetWardId(ward->GetWardId()); //Pega o id da ala
            //
            //Adiciona uma Ala nova para a tabela local 
            AddWardToTblWardsInSqLite(ward);
            //
        } else {
            //
            string erro_log = "getWardIDToWardRldInSqLite() : Ala não Cadastrada Nas "
                    "Tabelas de Pesquisa (wards) SQ/PG.";
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            //  
            /**
             * Como nao encontrou a Ala em nenhuma 
             * das duas tabelas nos dois bancos.
             * Entao descarta o evento removendo do
             * banco local.
             * @param event
             * @return 
             */
            runRemoveEventInSqLite(nevent);
        }
    }
    //
    return nevent;
}

/**
 * Metodo responsavel por pegar room_id
 * para ward_id e room_name
 * @param room
 * @return 
 */
Event* DbConn::getRoomIDToRoomRldInSqLite(Event *nevent) {
    string vroom_id;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM rooms WHERE room_name = ? AND ward_id = ?";

    msg->ShowMessage("Ward ID: " + nevent->GetWardId() + " : Quarto: " + nevent->GetRoomSigla(), COLOR_BLUE, COLOR_GREEN);

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, nevent->GetRoomSigla().c_str(), nevent->GetRoomSigla().length(), SQLITE_TRANSIENT);
    //
    sqlite3_bind_text(stmt, 2, nevent->GetWardId().c_str(), nevent->GetWardId().length(), SQLITE_TRANSIENT);
    // 

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vroom_id = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            //
            nevent->SetRoomId(vroom_id);
        }
        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getRoomIDToRoomRldInSqLite() : Não foi possível pegar o ID para Quarto Rauland para Tabela (rooms)."
                "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    if (vroom_id.empty()) {
        room = new Room();
        //
        /**
         * Como nao encontrou o evento na tabela
         * local do SqLite. Pesquis no PostgreSQL.
         */
        room = getRoomIDToRoomRldInPGree(nevent);
        //
        if (!room->GetRoomId().empty()) {
            //
            nevent->SetRoomId(room->GetRoomId()); //Pega o id do quarto
            //
            //Adiciona um evento novo para a tabela local 
            AddRoomToTblRoomsInSqLite(room);
            //
        } else {
            string erro_log = "getRoomIDToRoomRldInSqLite() : Quarto não Cadastrado Nas Tabelas de "
                    "Pesquisa (rooms) SQ/PG.";
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            //
            /**
             * Como nao encontrou o Quarto em nenhuma 
             * das duas tabelas nos dois bancos.
             * Entao descarta o evento removendo do
             * banco local.
             * @param event
             * @return 
             */
            runRemoveEventInSqLite(nevent);
        }
    }
    //
    return nevent;
}

/**
 * Metodo responsavel por pegar o id para 
 * para o cartao capturado, caso esteja
 * cadastrados.
 * @param ncard
 * @return 
 */
Card* DbConn::getCardIDToCardInSqLite(Card *ncard) {
    string vhexaid;
    string query;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM attendants WHERE hexacard = ?";

    msg->ShowMessage("HexaCard: " + ncard->GetHexa_Card(), COLOR_BLUE, COLOR_GREEN);

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, ncard->GetHexa_Card().c_str(), ncard->GetHexa_Card().length(), SQLITE_TRANSIENT);
    //

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vhexaid = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            //
            ncard->SetAttendant_Id(vhexaid);
        }
        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getCardIDToCardInSqLite() : Não foi possível pegar o ID para Atendente Rauland para Tabela (attendants)."
                "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    if (vhexaid.empty()) {
        /**
         * Executa o loop ate
         * encontrar o id do
         * cartao
         * @param ncard
         * @return 
         */
        while (1) {
            //
            evcard = new Card();

            /**
             * Como nao encontrou o evento na tabela
             * local do SqLite. Pesquis no PostgreSQL.
             */
            evcard = getCardIDToCardInPGree(ncard);


            /**
             * Se nao encontra o cartao no PostgreSQL..
             * vai para o ele para adicionar ele, para 
             * que possa pegar no proximo loop.
             * @param ncard
             * @return 
             */
            if (!evcard->GetAttendant_Id().empty()) {
                //
                ncard->SetAttendant_Id(evcard->GetAttendant_Id()); //Pega o id do cartao
                //
                //Adiciona um evento novo para a tabela local 
                AddCardToTblAttendantInSqLite(evcard);
                //
                break; //finaliza o loop
            } else {
                //
                msg->ShowMessage("Gravando Novo Cartao: " + ncard->GetHexa_Card(), COLOR_BLUE, COLOR_PINK);

                /***
                 * Query usada para incluir no servidor local os
                 * eventos capturado da porta serial.
                 */
                query = "INSERT INTO attendants(hexacard, attendant_code, attendant_name, date_time_add)  "
                        "VALUES('"
                        + ncard->GetHexa_Card() + "','"
                        + ncard->GetCode_Card() + "','"
                        + ncard->GetCode_Card() + "','"
                        + tmut->getTimeFormat("%Y-%m-%d %H:%M:%S") + "')";

                msg->ShowMessage("Query : " + query, COLOR_PINK, COLOR_BLUE);

                //Grava na base de dados
                runQueryInPGree(query);
            }
        }
    }
    //
    return ncard;
}

/**
 * Metodo responsavel por pegar a ala para 
 * o cartao capturado.
 * @param ncard
 * @return 
 */
Card* DbConn::getWardIDToWardCardInSqLite(Card *ncard) {
    string vward_id;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM wards WHERE ip_pds = ?";

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, ncard->GetWardPds().c_str(), ncard->GetWardPds().length(), SQLITE_TRANSIENT);

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        //
        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vward_id = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            ncard->SetWardId(vward_id);
        }
        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getWardIDToWardCardInSqLite() : Não foi possível pegar o ID para Ala "
                "do Cartão para Tabela (wards). Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);
    //
    return ncard;
}

/**
 * Metodo responsavel por pegar o id do quarto
 * para o quarto capturado do cartao
 * @param ncard
 * @return 
 */
Card* DbConn::getRoomIDToRoomCardInSqLite(Card *ncard) {
    string vroom_id;
    //
    char* errorMessage;
    //
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT * FROM rooms WHERE room_code = ? AND ward_id = ?";

    msg->ShowMessage("Ward ID: " + ncard->GetWardId() + " : Quarto: " + ncard->GetRoomCode(), COLOR_BLUE, COLOR_GREEN);

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    //Passa o parametro a ser pesquisado
    sqlite3_bind_text(stmt, 1, ncard->GetRoomCode().c_str(), ncard->GetRoomCode().length(), SQLITE_TRANSIENT);
    //
    sqlite3_bind_text(stmt, 2, ncard->GetWardId().c_str(), ncard->GetWardId().length(), SQLITE_TRANSIENT);
    // 

    rc = sqlite3_step(stmt);

    if (rc == SQLITE_ROW) {

        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            vroom_id = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            //
            ncard->SetRoomId(vroom_id);
        }
        //case SQLITE_INTEGER:
        //case SQLITE_FLOAT:
        //case SQLITE_TEXT:
        //case SQLITE_BLOB:	
        //case SQLITE_NULL:
    } else {
        //
        string erro_log = "getRoomIDToRoomCardInSqLite() : Não foi possível pegar o ID para Quarto do Cartão para Tabela (rooms)."
                "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //   
    }

    //limpar stmt
    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);

    //Nao pode ser descomentado ao trabalhar com 
    //Banco e tabela na memoria
    //   sqlite3_close(db);

    return ncard;
}

/**
 * Metodo responsavel por pegar o id para um 
 * Evento de Atendimento Espontaneo. Que er gerado
 * quando nao for encontrado um evento para ser 
 * atendido ou finalizado.
 * @param ncard
 * @return 
 */
Card* DbConn::getEventIDToAEInPGree(Card *ncard) {
    int i = 0;
    //
    string query = "SELECT * FROM table_events WHERE short_name = 'AE'";

    //Abre a conexao com o banco;
    if (openConnInPGree()) {

        rs = PQexec(conn, query.c_str());

        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            int nrows = PQntuples(rs); //Pego a quantidade de linhas no result
            //
            if (nrows > 0) {

                //ID
                char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                ncard->SetEventId(string(vid));
                /**
                 * Seta o leito do quarto para 
                 * que seja adicionado o evento
                 */
                ncard->SetRoomBedCode("1");
                //

            } else {
                //
                dir->setFolder_write("/Logs/LogDb/PgSql/");
                //
                string erro_query = "getEventIDToAEInPGree() :\nNao foi possivel pegar ID para o Evento de Atendimento"
                        " Espontaneo da tabela(table_events):\n" + query;
                dir->CreateLogFile("ERROQUERYAE", erro_query);
            }
        }
        //
        PQclear(rs);
        //Fecha a conexao com o PostgreSQL
        closeConnPGree();
        //
    }

    return ncard;
}

/**
 * Metodo responsavel por pesquisar
 * todos eventos em abertos para serem
 * testados e atendidos.
 * @return 
 */
vector<Event*> DbConn::getAllEventToApplyAssist(string query) {
    vector<Event*> vec_all_events;
    int i, nrows;
    msg->ShowMessage("Query: " + query, COLOR_BLUE, COLOR_PINK);

    //Abre a conexao com o banco;
    if (openConnInPGree()) {
        //
        rs = PQexec(conn, query.c_str());
        //
        if (!rs) {
            //
            char *erro_searc = PQerrorMessage(conn);
            string str_searc = string(erro_searc);
            msg->ShowMessage(str_searc, COLOR_BLUE, COLOR_RED);
            //
            PQclear(rs);
        } else {
            nrows = PQntuples(rs);

            if (nrows > 0) {
                for (i = 0; i < nrows; i++) {
                    evrld = new Event();

                    //ID
                    char *vid = PQgetvalue(rs, i, 0); //PQgetvalue(rs, i, 0), i=linha, 0=coluna

                    //DATE_TIME_CALLED
                    char *vdate_time_called = PQgetvalue(rs, i, 1);

                    //Id do Protocolo
                    evrld->SetPtlId(atoi(vid));
                    //
                    evrld->SetDate_Time_Called(string(vdate_time_called));

                    //Adiciona evento na lista
                    vec_all_events.push_back(evrld);
                }
            }

            PQclear(rs);
        }
        //Fecha a conexao
        closeConnPGree();
    }

    //
    return vec_all_events;
}

/**
 * Metodo responsavel por adicionar um evento
 * pesquisado para o evento rauland na tabela
 * de table_events na memoria.
 * @param nevent
 * @return 
 */
bool DbConn::AddEventToTblEventsInSqLite(Event *nevent) {
    //
    int rc, is_cancel;
    char* errorMessage;
    string erro_log;

    //
    msg->ShowMessage("Adicionando um Evento Padrão!!", COLOR_BLUE, COLOR_GREEN);
    //
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO table_events VALUES (?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
        //  
        is_cancel = nevent->IsEventCancel();
        //
        sqlite3_bind_int(stmt, 1, nevent->GetEventId()); //tem que incrementar id para incluir
        //sqlite3_bind_text(stmt, 2, evrld->GetEventCode().c_str(), evrld->GetEventCode().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 2, nevent->GetEventMessage().c_str(), nevent->GetEventMessage().size(), SQLITE_TRANSIENT);
        sqlite3_bind_int(stmt, 3, is_cancel);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "AddEventToTblEventsInSqLite() :\n Não foi possível adicionar um Novo Eventos Padrões Rauland, para o banco de dados. "
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "AddEventToTblEventsInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar um Novo Eventos Padrões Rauland,";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por adicionar uma ala
 * pesquisada para o evento rauland na tabela
 * de alas na memoria.
 * @param nward
 * @return 
 */
bool DbConn::AddWardToTblWardsInSqLite(Ward *nward) {
    int rc;
    char* errorMessage;
    string erro_log;
    //
    msg->ShowMessage("Adicionando um Alas Padrão!!", COLOR_BLUE, COLOR_GREEN);
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO wards VALUES (?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
        //  
        sqlite3_bind_int(stmt, 1, atoi(nward->GetWardId().c_str())); //tem que incrementar id para incluir
        sqlite3_bind_text(stmt, 2, nward->GetWardPds().c_str(), nward->GetWardPds().size(), SQLITE_TRANSIENT);
        // sqlite3_bind_text(stmt, 3, ward->GetWardCode().c_str(), ward->GetWardCode().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, nward->GetWardSigla().c_str(), nward->GetWardSigla().size(), SQLITE_TRANSIENT);
        // sqlite3_bind_text(stmt, 5, ward->GetWardName().c_str(), ward->GetWardName().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "AddWardToTblWardsInSqLite() : Não foi possível adicionar uma Nova Ala para o banco de dados. "
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);
    } else {
        //
        erro_log = "AddWardToTblWardsInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar uma Nova Ala";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por adicionar um quarto
 * pesquisado para o evento rauland na tabela
 * de quatos na memoria.
 * @param nroom
 * @return 
 */
bool DbConn::AddRoomToTblRoomsInSqLite(Room *nroom) {
    int rc, room_id, ward_id, room_code;
    char* errorMessage;
    string erro_log;
    //
    msg->ShowMessage("Adicionando um Novo Quarto Padrão!!", COLOR_BLUE, COLOR_GREEN);
    //
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO rooms VALUES (?, ?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
        //
        room_id = atoi(nroom->GetRoomId().c_str());
        ward_id = atoi(nroom->GetRoomWardId().c_str());
        room_code = atoi(nroom->GetRoomCode().c_str());
        //
        sqlite3_bind_int(stmt, 1, room_id); //tem que incrementar id para incluir
        sqlite3_bind_int(stmt, 2, ward_id);
        sqlite3_bind_int(stmt, 3, room_code);
        sqlite3_bind_text(stmt, 4, nroom->GetRoomName().c_str(), nroom->GetRoomName().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "AddRoomToTblRoomsInSqLite() : Não foi possível adicionar um Novo Quarto para o banco de dados. "
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "AddRoomToTblRoomsInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar um Novo Quarto";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //
    }
    //
    return true;
}

/**
 * Metodo responsavel por adicionar um novo cartao
 * para tabela local no SqLite
 * @param ncard
 * @return 
 */
bool DbConn::AddCardToTblAttendantInSqLite(Card *ncard) {
    int rc, card_id;
    char* errorMessage;
    string erro_log;
    //
    msg->ShowMessage("Adicionando um Novo Quarto Padrão!!", COLOR_BLUE, COLOR_GREEN);
    //
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO attendants VALUES (?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
        //
        card_id = atoi(ncard->GetAttendant_Id().c_str());

        //
        sqlite3_bind_int(stmt, 1, card_id); //tem que incrementar id para incluir
        sqlite3_bind_text(stmt, 2, ncard->GetHexa_Card().c_str(), ncard->GetHexa_Card().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "AddCardToTblAttendantInSqLite() : Não foi possível adicionar um Novo Cartão para o banco de dados. "
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "AddCardToTblAttendantInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar um Novo Cartão";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //
    }
    //
    return true;
}

/**
 * Executa uma query no banco
 * Sqlite
 * @return 
 */
bool DbConn::runAddEventInSqLite(Event* event) {
    //
    char* errorMessage;
    string erro_log;
    int rc;
    bool is_cancel;

    //  id, ward_name, room_name, bedroom_code, message_event,
    //  is_event_cancel, date_call, status_wait
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO event_rauland VALUES (?, ?, ?, ?, ?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);

        //Pega o proximo ID para inclusao
        int idreg = getLastIdFromTblSqLite("event_rauland");

        //
        is_cancel = event->IsEventCancel();
        //
        sqlite3_bind_int(stmt, 1, idreg); //tem que incrementar id para incluir
        sqlite3_bind_text(stmt, 2, event->GetWardSigla().c_str(), event->GetWardSigla().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, event->GetRoomName().c_str(), event->GetRoomName().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 4, event->GetRoomBedCode().c_str(), event->GetRoomBedCode().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 5, event->GetEventMessage().c_str(), event->GetEventMessage().size(), SQLITE_TRANSIENT);
        sqlite3_bind_int(stmt, 6, is_cancel);
        sqlite3_bind_text(stmt, 7, event->GetDate_Time_Called().c_str(), event->GetDate_Time_Called().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "runQueryInSqLite(Event* event) : Não foi possível adicionar Evento para Tabela (event_rauland)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "runQueryInSqLite(Event* event): Não foi possível abrir o banco de dados. "
                "para adicionar Evento para Tabela (event_rauland).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Adiciona um evento capturado da 
 * Rauland para a tabela de eventos
 * para validacao de duplicidade de 
 * eventos na memoria do
 * Sqlite, tabela (event_cap)
 * @return true or false
 */
bool DbConn::runAddEventValidInSqLite(Event *event) {
    //
    char* errorMessage;
    string erro_log;
    int rc;
    //  id, ward_name, room_name, message_event,
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO event_cap VALUES (?, ?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);

        //Pega o proximo ID para inclusao
        int idreg = getLastIdFromTblSqLite("event_cap");
        //
        sqlite3_bind_int(stmt, 1, idreg); //tem que incrementar id para incluir
        sqlite3_bind_text(stmt, 2, event->GetWardSigla().c_str(), event->GetWardSigla().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, event->GetRoomName().c_str(), event->GetRoomName().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 4, event->GetEventMessage().c_str(), event->GetEventMessage().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "runAddEventValidInSqLite() : Não foi possível adicionar Evento para Tabela (event_cap)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "runAddEventValidInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar Evento para Tabela (event_cap).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Atualiza um evento capturado da 
 * Rauland para a tabela event_cap
 * para validacao de duplicidade de 
 * eventos na memoria do Sqlite, 
 * tabela (event_cap)
 * @return true or false
 */
bool DbConn::runUpdateEventValidInSqLite(Event *event) {
    //UPDATE data_protocol SET date_time_entered =
    //
    char* errorMessage;
    string erro_log;
    int rc;

    //  id, ward_name, room_name, message_event,
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "UPDATE event_cap SET message_event = ? WHERE ward_name = ? AND room_name = ?";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);
        
        sqlite3_bind_text(stmt, 1, event->GetEventMessage().c_str(), event->GetEventMessage().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 2, event->GetWardSigla().c_str(), event->GetWardSigla().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, event->GetRoomName().c_str(), event->GetRoomName().size(), SQLITE_TRANSIENT);

        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "runUpdateEventValidInSqLite() : Não foi possível alterar Evento para Tabela (event_cap)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "runUpdateEventValidInSqLite(): Não foi possível abrir o banco de dados. "
                "para alterar Evento para Tabela (event_cap).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por validar se um evento
 * capturado er repetido para uma Ala e Quarto.
 * @param event
 * @return 
 */
bool DbConn::validEventCapRldInSqLite(Event *event) {
    bool result = false;
    //
    char* errorMessage;
    string vevent;
    //  id, ward_name, room_name, message_event,
    //
    //sqlite3 *db;
    sqlite3_stmt *stmt;
    int rc;
    string buffer;

    buffer = "SELECT message_event FROM event_cap WHERE ward_name = ? AND room_name = ? AND message_event = ?";

    cout << "Query: " << buffer + '\n' << "\n\n" << endl;

    rc = sqlite3_prepare_v2(dbSqLite, buffer.c_str(), strlen(buffer.c_str()), &stmt, NULL);

    sqlite3_bind_text(stmt, 1, event->GetWardSigla().c_str(), event->GetWardSigla().size(), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, event->GetRoomName().c_str(), event->GetRoomName().size(), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, event->GetEventMessage().c_str(), event->GetEventMessage().size(), SQLITE_TRANSIENT);

    rc = sqlite3_step(stmt);

    while (rc == SQLITE_ROW) {
        //
        if (SQLITE_NULL != sqlite3_column_type(stmt, 0)) {
            //
            vevent = reinterpret_cast<const char*> (sqlite3_column_text(stmt, 0));
            //
            cout << FG_BLUE << "Evento....:" << FG_GREEN << vevent << END << endl;
            //
            result = true;
        }
        //
        rc = sqlite3_step(stmt);
    }

    sqlite3_reset(stmt);

    sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
    sqlite3_finalize(stmt);
    //   sqlite3_close(db);//Nao usar, quando abrir em memoria
    //

    return result;
}

/**
 * Metodo responsavel por popular 
 * as alas e quartos para event_cap. 
 * Onde serao usados para comparar 
 * com os novos eventos que irao chegar. 
 * Assim evitando eventos duplicados. 
 * @return 
 */
bool DbConn::runAddWardRoomEventToCompareSqLite() {
    vector<Room*> vec_allrooms;
    bool result = false;
    //Stancia room
    room = new Room();
    //
    vec_allrooms = getAllWardRoomsToEventCap();
    //
    for (int i = 0; i < vec_allrooms.size(); i++) {
        room = vec_allrooms.at(i);
        //
        evrld = new Event();
        //
        evrld->SetRoomName(room->GetRoomName());
        //
        evrld->SetWardSigla(room->GetRoomWardSigla());
        //
        evrld->SetEventMessage("EVENT TEMP");
        //
        result = runAddEventValidInSqLite(evrld);
        //
    }
    //
    return result;
}

/**
 * Metodo responsavel por adicionar um 
 * evento de cartao capturado para tabela
 * temporaria de cartoes no SqLite
 * @param card
 * @return 
 */
bool DbConn::runAddHexaCardInSqLite(Card *card) {
    //
    char* errorMessage;
    string erro_log;
    int rc;

    //  id, ward_name, room_name, bedroom_code, message_event,
    //  is_event_cancel, date_call, status_wait
    //
    if (isOpenConnSqLite()) {
        //
        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "INSERT INTO event_card VALUES (?, ?, ?, ?)";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);

        //Pega o proximo ID para inclusao
        int idreg = getLastIdFromTblSqLite("event_card");
        //
        sqlite3_bind_int(stmt, 1, idreg); //tem que incrementar id para incluir
        sqlite3_bind_text(stmt, 2, card->GetWardPds().c_str(), card->GetWardPds().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 3, card->GetHexa_Card().c_str(), card->GetHexa_Card().size(), SQLITE_TRANSIENT);
        sqlite3_bind_text(stmt, 4, card->GetDate_Time_Called().c_str(), card->GetDate_Time_Called().size(), SQLITE_TRANSIENT);
        //
        rc = sqlite3_step(stmt);

        if (rc != SQLITE_DONE) {
            //
            erro_log = "runAddHexaCardInSqLite() : Não foi possível adicionar Evento de Cartão para Tabela (event_card)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITE", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);

        sqlite3_finalize(stmt);

    } else {
        //
        erro_log = "runAddHexaCardInSqLite(): Não foi possível abrir o banco de dados. "
                "para adicionar Evento do Cartão para Tabela (event_card).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        // 
    }
    //
    return true;
}

/**
 * Metodo responsavel por remover um evento
 * capturado da Rauland, previamente aplicada
 * a regra de negócio e atualizado no PostgreSQL.
 * @param nevent
 * @return 
 */
bool DbConn::runRemoveEventInSqLite(Event *nevent) {
    char* errorMessage;
    string erro_log;
    //
    if (isOpenConnSqLite()) {

        msg->ShowMessage("REMOVENDO EVENTOS TRATADOS!!!", COLOR_BLUE, COLOR_CIANO);

        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "DELETE FROM event_rauland WHERE date_call = ?";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);

        sqlite3_bind_text(stmt, 1, nevent->GetDate_Time_Called().c_str(), nevent->GetDate_Time_Called().size(), SQLITE_TRANSIENT);

        if (sqlite3_step(stmt) != SQLITE_DONE) {
            //
            erro_log = "runRemoveEventInSqLite() : Não foi possível Remover um Evento para Tabela (event_rauland)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITERM", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
        sqlite3_finalize(stmt);
        //   sqlite3_close(db);
    } else {
        //
        erro_log = "runRemoveEventInSqLite(): Não foi possível abrir o banco de dados. "
                "para Remover um evento para Tabela (event_rauland).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //         
    }
    //
    return true;
}

/**
 * Metodo responsavel por remover um evento
 * Capturado do PDS200, previamente aplicada
 * a regra de negócio e atualizado no PostgreSQL.
 * @param ncard
 * @return 
 */
bool DbConn::runRemoveEventInSqLite(Card *ncard) {
    char* errorMessage;
    string erro_log;
    //
    if (isOpenConnSqLite()) {

        msg->ShowMessage("REMOVENDO EVENTOS TRATADOS!!! --> " + tmut->ConvIntToString(ncard->GetIdAdd()), COLOR_BLUE, COLOR_CIANO);

        sqlite3_exec(dbSqLite, "BEGIN TRANSACTION", NULL, NULL, &errorMessage);

        char buffer[] = "DELETE FROM event_card WHERE id = ?";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(dbSqLite, buffer, strlen(buffer), &stmt, NULL);

        sqlite3_bind_int(stmt, 1, ncard->GetIdAdd());

        if (sqlite3_step(stmt) != SQLITE_DONE) {
            //
            erro_log = "runRemoveEventInSqLite() : Não foi possível Remover um Evento de Cartão para Tabela (event_card)."
                    "Erro: -> " + string(sqlite3_errmsg(dbSqLite));
            //
            msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
            //
            dir->setFolder_write("/Logs/LogDb/Sqlite/");
            //
            dir->CreateLogFile("LOGSQLITERM", erro_log);
            // 
            return false;
        }

        sqlite3_reset(stmt);

        sqlite3_exec(dbSqLite, "COMMIT TRANSACTION", NULL, NULL, &errorMessage);
        sqlite3_finalize(stmt);
        //   sqlite3_close(db);
    } else {
        //
        erro_log = "runRemoveEventInSqLite(): Não foi possível abrir o banco de dados. "
                "para Remover um Evento de Cartão para Tabela (event_card).";
        //
        msg->ShowMessage(erro_log, COLOR_BLUE, COLOR_RED);
        //
        dir->setFolder_write("/Logs/LogDb/Sqlite/");
        //
        dir->CreateLogFile("LOGSQLITE", erro_log);
        //         
    }
    //
    return true;
}